Introduction

Most of the time, confidentiality is not enough - it needs to be combined with integrity in order for an application to be secure. So, even if an encryption scheme is CCA-secure, there is still room for ciphertext forgery. This necessitates even stronger security notions which are satisfied by authenticated encryption schemes.

Definition: Authenticated Encryption (AE-Security)

A cipher $(Enc, Dec)$ is an authenticated encryption scheme or is AE-secure if it is CPA-secure and provides ciphertext integrity (CI).

AE-security is the most widely adopted security notion and is ubiquitous in web applications. It is stronger than CCA-security - the constructs which satisfy AE-security also satisfy CCA-security. However, there is no real efficiency difference between ciphers which are AE-secure and ciphers which are only CCA-secure.

Theorem: AE-Security implies CCA-Security

Every AE-secure cipher is also CCA-secure.

Proof: AE-Security implies CCA-Security

Let $(Enc, Dec)$ be an AE-secure cipher and let $Mallory$ be a CCA-adversary. In particular, suppose that Mallory makes $q_{e}$ encryption queries to obtain the plaintext-ciphertext pairs $(m_{1}, c_{1}), (m_{2}, c_{2}), ..., (m_{q_{e}}, c_{q_{e}})$ and also makes $q_{d}$ decryption queries to obtain the ciphertext-plaintext pairs $(c_{1}^{'}, m_{1}^{'}), (c_{2}^{'}, m_{2}^{'}), ..., (c_{q_{d}}^{'}, m_{q_{d}}^{'})$ .

Since the cipher is AE-secure and thus provides ciphertext integrity, the probability that in a given decryption query Mallory finds a ciphertext $c_{j}^{'}$ such that $Dec_{k} (c_{j}^{'}) \neq = error$ is negligible. Mallory sumbits $q_{d}$ queries, so the probability that any of them turn out to be valid is $q_{d} \cdot negl (n)$ , which is also negligible. This means that the decryption queries do not help Mallory in any way and can be ignored, thereby reducing the CCA scenario to a CPA one. AE-security provides CPA-security by definition, which completes the proof.

This explains why ciphers which are only CCA-secure are rarely used in practice - why would you opt for less security when there is not even an efficiency benefit?

Implementation

There are many ways to implement authenticated encryption. Some include combining a CPA-secure cipher with a secure

Construction from a Cipher and a MAC

AE-secure encryption schemes can be constructed by combining a CPA-secure cipher $(Enc^{'}, Dec^{'})$ with a CMA-secure message authentication code system $(Sign, Verify)$ . Such approaches use two separate keys - $k_{E}$ for encryption / decryption and $k_{S}$ for message signing and verification. These keys must be independent of each other.

However, it turns out that not all ways of combining these two systems yield an authenticated encryption and even if the correct approach is used, the keys $k_{E}$ and $k_{S}$ must still be completely independent, lest AE-security is broken.

Encrypt-and-Sign

In this approach, encryption and message signing are carried out independently from each other and in parallel. The supposedly AE-secure cipher $(Enc, Dec)$ is constructed by encrypting the message $m$ with some encryption function $Enc^{'}$ to produce a ciphertext $c$ . The message is also separately signed by the MAC and the resulting tag $τ$ is appended to $c$ .

$c : = Enc_{k_{E}}^{'} (m)$ $τ : = Sign_{k_{S}} (m)$

The final ciphertext is the concatenation of $c$ and the message tag $τ$ , i.e.

$Enc (k_{E}, k_{S}, m) : = c ∣∣ τ$

To decrypt the ciphertext $c$ , the decryption function first parses it back into a message ciphertext and a message tag $τ$ . It then decrypts the ciphertext using $Dec_{k_{E}}^{'}$ to obtain the message $m$ . Finally, it verifies the decrypted message with the tag $τ$ . If the message is valid, then it is returned. Otherwise, an error is produced.

$Dec (k_{E}, k_{S}, c ∣∣ τ) = {Dec_{k_{E}}^{'} (c), if Dec_{k_{E}}^{'} (c) \neq = error and Verify (k_{S}, Dec_{k_{E}}^{'} (c), τ) = 1 error, otherwise$

This is certainly a good attempt at constructing an authenticated encryption but it fails horribly.

Warning

The Encrypt-and-Sign approach is not AE-secure.

Since the message $m$ is signed directly before being encrypted, nothing is stopping the tag $τ$ from leaking information about it (CMA-secure MACs provide no secrecy guarantees). For example, a MAC might be CMA-secure but have tags whose first bit is always identical to the first bit of the message. This means that the Encrypt-and-Sign method might not even be semantically security.

Moreover, it is not CPA-secure because deterministic MACs will produce the same tag when given the same message, provided that the same signing key $k_{S}$ is used. This is a real concern, since most MAC systems used in practice are deterministic.

Sign-then-Encrypt

In this approach the first step is to compute the tag $τ$ of the message $m$ , i.e. $τ : = Sign_{k_{S}} (m)$ . It is then appended to the message $m$ and the resulting concatenation is what actually gets encrypted to obtain the ciphertext $c$ .

$Enc (k_{E}, k_{S}, m) = Enc_{k_{E}}^{'} (m ∣∣ τ)$

The decryption function decrypts the ciphertext $c$ to obtain the concatenation of the message $m$ with the tag $τ$ and then verifies them. If either $Dec^{'}$ or validation result in an error, then $Dec$ simply errors out.

$Dec (k_{E}, k_{S}, m) = {Dec_{k_{E}}^{'} (c), if Dec_{k_{E}}^{'} (c) \neq = error and Verify (k_{S}, m, τ) = 1 error, otherwise$

Warning

The Sign-then-Encrypt approach may be AE-secure, but this depends highly on the specifics of the cipher and the MAC used. Since it does not provide AE-security in the general case of an arbitrary cipher and an arbitrary MAC, it should be avoided - there is simply too much room for mistakes when implementing it.

For example, if there are different error types depending on whether validation or decryption fails, something which is very much necessary in practice, then the security of this approach can be broken by padding oracle attacks.

Encrypt-then-Sign

This approach requires a MAC system with strong unforgeablity. First, the message is encrypted. The resulting ciphertext $c$ is then signed and the tag $τ$ is appended to it to obtain the final ciphertext.

$c : = Enc_{k_{E}}^{'} (m)$ $τ : = Sign_{k_{S}} (c)$ $Enc (k_{E}, k_{S}, m) : = c ∣∣ τ$

The decryption function parses the ciphertext $c ∣∣ τ$ back into a message ciphertext and a ciphertext tag $τ$ . If ciphertext verification fails, then it returns an error. Otherwise, it returns the decryption of $c$ .

$Dec (k_{E}, k_{S}, c ∣∣ τ) : = {Dec_{k_{E}}^{'} (c), if Verify (k_{S}, c, τ) = 1 error otherwise$

This approach is quite similar to Encrypt-and-Sign, but the tag is computed on the ciphertext instead of the plaintext. This small difference turns out to be crucial as it is what makes Encrypt-then-Sign AE-secure. Since the tag is verifying the ciphertext, no adversary can tamper with it. This reduces any CCA adversary to a CPA adversary and the CPA-security of $(Enc^{'}, Dec^{'})$ guarantees protection against this.

Proof: AE-Security of Encrypt-then-Sign

Suppose that $A$ is a CCA adversary.

For each of the adversary's decryption queries, the strong unforgeability of the MAC guarantees that the probability that $A$ can produce a valid ciphertext $c ∣∣ τ$ is negligible, since to produce such a ciphertext, $A$ would have to find a valid ciphertext-tag pair. The MAC system is secure, so this only happens with probability at most $\frac{1}{2 ^{n}} + negl(n)$ , which is negligible. If $A$ makes $q$ decryption queries, then the probability that one of them is valid is $q (\frac{1}{2 ^{n}} + negl (n))$ which is also negligible, since $q$ has to be polynomial. This means that the cipher provides ciphertext integrity (CI), even in the more empowering scenario which allows $A$ to submit decryption queries.

What remains is to prove that the cipher $(Enc, Dec^{'})$ is CPA-secure (remember that CPA-security combined with the already established ciphertext integrity implies CCA-security). Suppose, towards contradiction, that $B$ is a CPA adversary which can break the CPA-security of $(Enc, Dec)$ , i.e. $B$ can distinguish if a ciphertext $c ∣∣ τ$ is the encryption of $m_{a}$ or $m_{b}$ with probability $\frac{1}{2} + nonnegl (n)$ .

Now, let $B^{'}$ be a CPA adversary against $(Enc^{'}, Dec^{'})$ . When $B^{'}$ receives its challenge ciphertext $c$ , it will compute its tag $τ$ (this is allowed because the signing key $k_{S}$ is different from the encryption key $k_{E}$ ) and then it will forward $c ∣∣ τ$ together with $m_{a}$ and $m_{b}$ to $B$ . However, the adversary $B$ is also a CPA adversary (albeit against $(Enc, Dec)$ ) and may thus require encryption queries to achieve its goal. This is no problem as $B^{'}$ can provide answers to any encryption queries that $B$ might have. Whenever $B$ submits a plaintext $m$ as a query, the adversary $B^{'}$ will be able to fulfil it by using its own encryption oracle $Enc^{'}$ and then computing the tag for the resulting ciphertext.

Ultimately, $B^{'}$ will output whichever message, either $m_{a}$ or $m_{b}$ , that $B$ does. Since $B$ will guess correctly if $c ∣∣ τ$ is the encryption of $m_{a}$ or $m_{b}$ with probability $\frac{1}{2} + nonnegl (n)$ , then $B^{'}$ will guess if $c$ is the encryption of $m_{a}$ or $m_{b}$ with probability $\frac{1}{2} + nonnegl (n)$ . This is a contradiction, since it would be a breach of the CPA-security of $(Enc^{'}, Dec^{'})$ .

It is paramount that the MAC system used has strong unforgeability. Otherwise, a CCA adversary challenged with a ciphertext $c ∣∣ τ$ can generate a new valid tag $τ^{'}$ for $c$ with non-negligible probability. Since $c ∣∣ τ \neq = c ∣∣ τ^{'}$ , the adversary is allowed to submit this new tag $τ^{'}$ with $c$ to its decryption oracle which will pass verification. The decryption oracle will then hand the exact decryption of $c$ to the adversary and so they will know for sure if $c$ was the encryption of some message $m_{a}$ or another message $m_{b}$ . This would be a breach of CCA-security and therefore also a breach of AE-security.